home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / utils / ObjectUtil.as < prev    next >
Encoding:
Text File  |  2009-02-12  |  26.8 KB  |  872 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import flash.utils.getQualifiedClassName;
  6.    import flash.xml.XMLNode;
  7.    import mx.collections.IList;
  8.    import mx.core.mx_internal;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class ObjectUtil
  13.    {
  14.       mx_internal static const VERSION:String = "3.0.0.0";
  15.       
  16.       private static var defaultToStringExcludes:Array = ["password","credentials"];
  17.       
  18.       private static var refCount:int = 0;
  19.       
  20.       private static var CLASS_INFO_CACHE:Object = {};
  21.       
  22.       public function ObjectUtil()
  23.       {
  24.          super();
  25.       }
  26.       
  27.       public static function isSimple(param1:Object) : Boolean
  28.       {
  29.          var _loc2_:* = typeof param1;
  30.          switch(_loc2_)
  31.          {
  32.             case "number":
  33.             case "string":
  34.             case "boolean":
  35.                return true;
  36.             case "object":
  37.                return param1 is Date || param1 is Array;
  38.             default:
  39.                return false;
  40.          }
  41.       }
  42.       
  43.       private static function internalToString(param1:Object, param2:int = 0, param3:Dictionary = null, param4:Array = null, param5:Array = null) : String
  44.       {
  45.          var str:String = null;
  46.          var classInfo:Object = null;
  47.          var properties:Array = null;
  48.          var id:Object = null;
  49.          var isArray:Boolean = false;
  50.          var isDict:Boolean = false;
  51.          var prop:* = undefined;
  52.          var j:int = 0;
  53.          var value:Object = param1;
  54.          var indent:int = param2;
  55.          var refs:Dictionary = param3;
  56.          var namespaceURIs:Array = param4;
  57.          var exclude:Array = param5;
  58.          var type:String = value == null ? "null" : typeof value;
  59.          switch(type)
  60.          {
  61.             case "boolean":
  62.             case "number":
  63.                return value.toString();
  64.             case "string":
  65.                return "\"" + value.toString() + "\"";
  66.             case "object":
  67.                if(value is Date)
  68.                {
  69.                   return value.toString();
  70.                }
  71.                if(value is XMLNode)
  72.                {
  73.                   return value.toString();
  74.                }
  75.                if(value is Class)
  76.                {
  77.                   return "(" + getQualifiedClassName(value) + ")";
  78.                }
  79.                classInfo = getClassInfo(value,exclude,{
  80.                   "includeReadOnly":true,
  81.                   "uris":namespaceURIs
  82.                });
  83.                properties = classInfo.properties;
  84.                str = "(" + classInfo.name + ")";
  85.                if(refs == null)
  86.                {
  87.                   refs = new Dictionary(true);
  88.                }
  89.                id = refs[value];
  90.                if(id != null)
  91.                {
  92.                   str += "#" + int(id);
  93.                   return str;
  94.                }
  95.                if(value != null)
  96.                {
  97.                   str += "#" + refCount.toString();
  98.                   refs[value] = refCount;
  99.                   ++refCount;
  100.                }
  101.                isArray = value is Array;
  102.                isDict = value is Dictionary;
  103.                indent += 2;
  104.                j = 0;
  105.                while(j < properties.length)
  106.                {
  107.                   str = newline(str,indent);
  108.                   prop = properties[j];
  109.                   if(isArray)
  110.                   {
  111.                      str += "[";
  112.                   }
  113.                   else if(isDict)
  114.                   {
  115.                      str += "{";
  116.                   }
  117.                   if(isDict)
  118.                   {
  119.                      str += internalToString(prop,indent,refs,namespaceURIs,exclude);
  120.                   }
  121.                   else
  122.                   {
  123.                      str += prop.toString();
  124.                   }
  125.                   if(isArray)
  126.                   {
  127.                      str += "] ";
  128.                   }
  129.                   else if(isDict)
  130.                   {
  131.                      str += "} = ";
  132.                   }
  133.                   else
  134.                   {
  135.                      str += " = ";
  136.                   }
  137.                   try
  138.                   {
  139.                      str += internalToString(value[prop],indent,refs,namespaceURIs,exclude);
  140.                   }
  141.                   catch(e:Error)
  142.                   {
  143.                      str += "?";
  144.                   }
  145.                   j++;
  146.                }
  147.                indent -= 2;
  148.                return str;
  149.                break;
  150.             case "xml":
  151.                return value.toString();
  152.             default:
  153.                return "(" + type + ")";
  154.          }
  155.       }
  156.       
  157.       public static function getClassInfo(param1:Object, param2:Array = null, param3:Object = null) : Object
  158.       {
  159.          var isDict:Boolean;
  160.          var excludeObject:Object;
  161.          var dynamic:Boolean;
  162.          var isArray:Boolean;
  163.          var propertyNames:Array;
  164.          var n:int = 0;
  165.          var i:int = 0;
  166.          var result:Object = null;
  167.          var cacheKey:String = null;
  168.          var className:String = null;
  169.          var classAlias:String = null;
  170.          var properties:XMLList = null;
  171.          var prop:XML = null;
  172.          var metadataInfo:Object = null;
  173.          var classInfo:XML = null;
  174.          var numericIndex:Boolean = false;
  175.          var key:* = undefined;
  176.          var p:String = null;
  177.          var pi:Number = NaN;
  178.          var uris:Array = null;
  179.          var uri:String = null;
  180.          var qName:QName = null;
  181.          var j:int = 0;
  182.          var obj:Object = param1;
  183.          var excludes:Array = param2;
  184.          var options:Object = param3;
  185.          if(obj is ObjectProxy)
  186.          {
  187.             obj = ObjectProxy(obj).object_proxy::object;
  188.          }
  189.          if(options == null)
  190.          {
  191.             options = {
  192.                "includeReadOnly":true,
  193.                "uris":null,
  194.                "includeTransient":true
  195.             };
  196.          }
  197.          propertyNames = [];
  198.          dynamic = false;
  199.          if(typeof obj == "xml")
  200.          {
  201.             className = "XML";
  202.             properties = obj.text();
  203.             if(properties.length())
  204.             {
  205.                propertyNames.push("*");
  206.             }
  207.             properties = obj.attributes();
  208.          }
  209.          else
  210.          {
  211.             classInfo = DescribeTypeCache.describeType(obj).typeDescription;
  212.             className = classInfo.@name.toString();
  213.             classAlias = classInfo.@alias.toString();
  214.             dynamic = classInfo.@isDynamic.toString() == "true";
  215.             if(options.includeReadOnly)
  216.             {
  217.                properties = classInfo..accessor.(@access != "writeonly") + classInfo..variable;
  218.             }
  219.             else
  220.             {
  221.                properties = classInfo..accessor.(@access == "readwrite") + classInfo..variable;
  222.             }
  223.             numericIndex = false;
  224.          }
  225.          if(!dynamic)
  226.          {
  227.             cacheKey = getCacheKey(obj,excludes,options);
  228.             result = CLASS_INFO_CACHE[cacheKey];
  229.             if(result != null)
  230.             {
  231.                return result;
  232.             }
  233.          }
  234.          result = {};
  235.          result["name"] = className;
  236.          result["alias"] = classAlias;
  237.          result["properties"] = propertyNames;
  238.          result["dynamic"] = dynamic;
  239.          result["metadata"] = metadataInfo = recordMetadata(properties);
  240.          excludeObject = {};
  241.          if(excludes)
  242.          {
  243.             n = int(excludes.length);
  244.             i = 0;
  245.             while(i < n)
  246.             {
  247.                excludeObject[excludes[i]] = 1;
  248.                i++;
  249.             }
  250.          }
  251.          isArray = className == "Array";
  252.          isDict = className == "flash.utils::Dictionary";
  253.          if(isDict)
  254.          {
  255.             for(key in obj)
  256.             {
  257.                propertyNames.push(key);
  258.             }
  259.          }
  260.          else if(dynamic)
  261.          {
  262.             for(p in obj)
  263.             {
  264.                if(excludeObject[p] != 1)
  265.                {
  266.                   if(isArray)
  267.                   {
  268.                      pi = parseInt(p);
  269.                      if(isNaN(pi))
  270.                      {
  271.                         propertyNames.push(new QName("",p));
  272.                      }
  273.                      else
  274.                      {
  275.                         propertyNames.push(pi);
  276.                      }
  277.                   }
  278.                   else
  279.                   {
  280.                      propertyNames.push(new QName("",p));
  281.                   }
  282.                }
  283.             }
  284.             numericIndex = isArray && !isNaN(Number(p));
  285.          }
  286.          if(!(isArray || isDict || className == "Object"))
  287.          {
  288.             if(className == "XML")
  289.             {
  290.                n = int(properties.length());
  291.                i = 0;
  292.                while(i < n)
  293.                {
  294.                   p = properties[i].name();
  295.                   if(excludeObject[p] != 1)
  296.                   {
  297.                      propertyNames.push(new QName("","@" + p));
  298.                   }
  299.                   i++;
  300.                }
  301.             }
  302.             else
  303.             {
  304.                n = int(properties.length());
  305.                uris = options.uris;
  306.                i = 0;
  307.                for(; i < n; i++)
  308.                {
  309.                   prop = properties[i];
  310.                   p = prop.@name.toString();
  311.                   uri = prop.@uri.toString();
  312.                   if(excludeObject[p] != 1)
  313.                   {
  314.                      if(!(!options.includeTransient && internalHasMetadata(metadataInfo,p,"Transient")))
  315.                      {
  316.                         if(uris != null)
  317.                         {
  318.                            if(uris.length == 1 && uris[0] == "*")
  319.                            {
  320.                               qName = new QName(uri,p);
  321.                               try
  322.                               {
  323.                                  obj[qName];
  324.                                  propertyNames.push();
  325.                               }
  326.                               catch(e:Error)
  327.                               {
  328.                               }
  329.                            }
  330.                            else
  331.                            {
  332.                               j = 0;
  333.                               while(j < uris.length)
  334.                               {
  335.                                  uri = uris[j];
  336.                                  if(prop.@uri.toString() == uri)
  337.                                  {
  338.                                     qName = new QName(uri,p);
  339.                                     try
  340.                                     {
  341.                                        obj[qName];
  342.                                        propertyNames.push(qName);
  343.                                     }
  344.                                     catch(e:Error)
  345.                                     {
  346.                                     }
  347.                                  }
  348.                                  j++;
  349.                               }
  350.                            }
  351.                         }
  352.                         else if(uri.length == 0)
  353.                         {
  354.                            qName = new QName(uri,p);
  355.                            try
  356.                            {
  357.                               obj[qName];
  358.                               propertyNames.push(qName);
  359.                            }
  360.                            catch(e:Error)
  361.                            {
  362.                            }
  363.                            continue;
  364.                         }
  365.                      }
  366.                   }
  367.                }
  368.             }
  369.          }
  370.          propertyNames.sort(Array.CASEINSENSITIVE | (numericIndex ? Array.NUMERIC : 0));
  371.          if(!isDict)
  372.          {
  373.             i = 0;
  374.             while(i < propertyNames.length - 1)
  375.             {
  376.                if(propertyNames[i].toString() == propertyNames[i + 1].toString())
  377.                {
  378.                   propertyNames.splice(i,1);
  379.                   i--;
  380.                }
  381.                i++;
  382.             }
  383.          }
  384.          if(!dynamic)
  385.          {
  386.             cacheKey = getCacheKey(obj,excludes,options);
  387.             CLASS_INFO_CACHE[cacheKey] = result;
  388.          }
  389.          return result;
  390.       }
  391.       
  392.       private static function arrayCompare(param1:Array, param2:Array, param3:int, param4:int, param5:Dictionary) : int
  393.       {
  394.          var _loc7_:Object = null;
  395.          var _loc6_:int = 0;
  396.          if(param1.length != param2.length)
  397.          {
  398.             if(param1.length < param2.length)
  399.             {
  400.                _loc6_ = -1;
  401.             }
  402.             else
  403.             {
  404.                _loc6_ = 1;
  405.             }
  406.          }
  407.          else
  408.          {
  409.             for(_loc7_ in param1)
  410.             {
  411.                if(!param2.hasOwnProperty(_loc7_))
  412.                {
  413.                   return -1;
  414.                }
  415.                _loc6_ = internalCompare(param1[_loc7_],param2[_loc7_],param3,param4,param5);
  416.                if(_loc6_ != 0)
  417.                {
  418.                   return _loc6_;
  419.                }
  420.             }
  421.             for(_loc7_ in param2)
  422.             {
  423.                if(!param1.hasOwnProperty(_loc7_))
  424.                {
  425.                   return 1;
  426.                }
  427.             }
  428.          }
  429.          return _loc6_;
  430.       }
  431.       
  432.       public static function stringCompare(param1:String, param2:String, param3:Boolean = false) : int
  433.       {
  434.          if(param1 == null && param2 == null)
  435.          {
  436.             return 0;
  437.          }
  438.          if(param1 == null)
  439.          {
  440.             return 1;
  441.          }
  442.          if(param2 == null)
  443.          {
  444.             return -1;
  445.          }
  446.          if(param3)
  447.          {
  448.             param1 = param1.toLocaleLowerCase();
  449.             param2 = param2.toLocaleLowerCase();
  450.          }
  451.          var _loc4_:int = int(param1.localeCompare(param2));
  452.          if(_loc4_ < -1)
  453.          {
  454.             _loc4_ = -1;
  455.          }
  456.          else if(_loc4_ > 1)
  457.          {
  458.             _loc4_ = 1;
  459.          }
  460.          return _loc4_;
  461.       }
  462.       
  463.       public static function dateCompare(param1:Date, param2:Date) : int
  464.       {
  465.          if(param1 == null && param2 == null)
  466.          {
  467.             return 0;
  468.          }
  469.          if(param1 == null)
  470.          {
  471.             return 1;
  472.          }
  473.          if(param2 == null)
  474.          {
  475.             return -1;
  476.          }
  477.          var _loc3_:Number = Number(param1.getTime());
  478.          var _loc4_:Number = Number(param2.getTime());
  479.          if(_loc3_ < _loc4_)
  480.          {
  481.             return -1;
  482.          }
  483.          if(_loc3_ > _loc4_)
  484.          {
  485.             return 1;
  486.          }
  487.          return 0;
  488.       }
  489.       
  490.       public static function numericCompare(param1:Number, param2:Number) : int
  491.       {
  492.          if(isNaN(param1) && isNaN(param2))
  493.          {
  494.             return 0;
  495.          }
  496.          if(isNaN(param1))
  497.          {
  498.             return 1;
  499.          }
  500.          if(isNaN(param2))
  501.          {
  502.             return -1;
  503.          }
  504.          if(param1 < param2)
  505.          {
  506.             return -1;
  507.          }
  508.          if(param1 > param2)
  509.          {
  510.             return 1;
  511.          }
  512.          return 0;
  513.       }
  514.       
  515.       private static function newline(param1:String, param2:int = 0) : String
  516.       {
  517.          var _loc3_:* = param1;
  518.          _loc3_ += "\n";
  519.          var _loc4_:int = 0;
  520.          while(_loc4_ < param2)
  521.          {
  522.             _loc3_ += " ";
  523.             _loc4_++;
  524.          }
  525.          return _loc3_;
  526.       }
  527.       
  528.       private static function recordMetadata(param1:XMLList) : Object
  529.       {
  530.          var prop:XML = null;
  531.          var propName:String = null;
  532.          var metadataList:XMLList = null;
  533.          var metadata:Object = null;
  534.          var md:XML = null;
  535.          var mdName:String = null;
  536.          var argsList:XMLList = null;
  537.          var value:Object = null;
  538.          var arg:XML = null;
  539.          var existing:Object = null;
  540.          var argKey:String = null;
  541.          var argValue:String = null;
  542.          var existingArray:Array = null;
  543.          var properties:XMLList = param1;
  544.          var result:Object = null;
  545.          try
  546.          {
  547.             for each(prop in properties)
  548.             {
  549.                propName = prop.attribute("name").toString();
  550.                metadataList = prop.metadata;
  551.                if(metadataList.length() > 0)
  552.                {
  553.                   if(result == null)
  554.                   {
  555.                      result = {};
  556.                   }
  557.                   metadata = {};
  558.                   result[propName] = metadata;
  559.                   for each(md in metadataList)
  560.                   {
  561.                      mdName = md.attribute("name").toString();
  562.                      argsList = md.arg;
  563.                      value = {};
  564.                      for each(arg in argsList)
  565.                      {
  566.                         argKey = arg.attribute("key").toString();
  567.                         if(argKey != null)
  568.                         {
  569.                            argValue = arg.attribute("value").toString();
  570.                            value[argKey] = argValue;
  571.                         }
  572.                      }
  573.                      existing = metadata[mdName];
  574.                      if(existing != null)
  575.                      {
  576.                         if(existing is Array)
  577.                         {
  578.                            existingArray = existing as Array;
  579.                         }
  580.                         else
  581.                         {
  582.                            existingArray = [];
  583.                         }
  584.                         existingArray.push(value);
  585.                         existing = existingArray;
  586.                      }
  587.                      else
  588.                      {
  589.                         existing = value;
  590.                      }
  591.                      metadata[mdName] = existing;
  592.                   }
  593.                }
  594.             }
  595.          }
  596.          catch(e:Error)
  597.          {
  598.          }
  599.          return result;
  600.       }
  601.       
  602.       public static function compare(param1:Object, param2:Object, param3:int = -1) : int
  603.       {
  604.          return internalCompare(param1,param2,0,param3,new Dictionary(true));
  605.       }
  606.       
  607.       private static function listCompare(param1:IList, param2:IList, param3:int, param4:int, param5:Dictionary) : int
  608.       {
  609.          var _loc7_:int = 0;
  610.          var _loc6_:int = 0;
  611.          if(param1.length != param2.length)
  612.          {
  613.             if(param1.length < param2.length)
  614.             {
  615.                _loc6_ = -1;
  616.             }
  617.             else
  618.             {
  619.                _loc6_ = 1;
  620.             }
  621.          }
  622.          else
  623.          {
  624.             _loc7_ = 0;
  625.             while(_loc7_ < param1.length)
  626.             {
  627.                _loc6_ = internalCompare(param1.getItemAt(_loc7_),param2.getItemAt(_loc7_),param3 + 1,param4,param5);
  628.                if(_loc6_ != 0)
  629.                {
  630.                   _loc7_ = param1.length;
  631.                }
  632.                _loc7_++;
  633.             }
  634.          }
  635.          return _loc6_;
  636.       }
  637.       
  638.       private static function internalCompare(param1:Object, param2:Object, param3:int, param4:int, param5:Dictionary) : int
  639.       {
  640.          var _loc9_:int = 0;
  641.          var _loc10_:Boolean = false;
  642.          var _loc11_:Boolean = false;
  643.          var _loc12_:Array = null;
  644.          var _loc13_:Array = null;
  645.          var _loc14_:QName = null;
  646.          var _loc15_:Object = null;
  647.          var _loc16_:Object = null;
  648.          var _loc17_:int = 0;
  649.          if(param1 == null && param2 == null)
  650.          {
  651.             return 0;
  652.          }
  653.          if(param1 == null)
  654.          {
  655.             return 1;
  656.          }
  657.          if(param2 == null)
  658.          {
  659.             return -1;
  660.          }
  661.          if(param1 is ObjectProxy)
  662.          {
  663.             param1 = ObjectProxy(param1).object_proxy::object;
  664.          }
  665.          if(param2 is ObjectProxy)
  666.          {
  667.             param2 = ObjectProxy(param2).object_proxy::object;
  668.          }
  669.          var _loc6_:* = typeof param1;
  670.          var _loc7_:* = typeof param2;
  671.          var _loc8_:int = 0;
  672.          if(_loc6_ == _loc7_)
  673.          {
  674.             switch(_loc6_)
  675.             {
  676.                case "boolean":
  677.                   _loc8_ = numericCompare(Number(param1),Number(param2));
  678.                   break;
  679.                case "number":
  680.                   _loc8_ = numericCompare(param1 as Number,param2 as Number);
  681.                   break;
  682.                case "string":
  683.                   _loc8_ = stringCompare(param1 as String,param2 as String);
  684.                   break;
  685.                case "object":
  686.                   _loc9_ = param4 > 0 ? param4 - 1 : param4;
  687.                   _loc10_ = Boolean(param5[param1]);
  688.                   _loc11_ = Boolean(param5[param2]);
  689.                   if(_loc10_ && !_loc11_)
  690.                   {
  691.                      return 1;
  692.                   }
  693.                   if(_loc11_ && !_loc10_)
  694.                   {
  695.                      return -1;
  696.                   }
  697.                   if(_loc11_ && _loc10_)
  698.                   {
  699.                      return 0;
  700.                   }
  701.                   param5[param1] = true;
  702.                   param5[param2] = true;
  703.                   if(param4 != -1 && param3 > param4)
  704.                   {
  705.                      _loc8_ = stringCompare(param1.toString(),param2.toString());
  706.                   }
  707.                   else if(param1 is Array && param2 is Array)
  708.                   {
  709.                      _loc8_ = arrayCompare(param1 as Array,param2 as Array,param3,param4,param5);
  710.                   }
  711.                   else if(param1 is Date && param2 is Date)
  712.                   {
  713.                      _loc8_ = dateCompare(param1 as Date,param2 as Date);
  714.                   }
  715.                   else if(param1 is IList && param2 is IList)
  716.                   {
  717.                      _loc8_ = listCompare(param1 as IList,param2 as IList,param3,param4,param5);
  718.                   }
  719.                   else if(param1 is ByteArray && param2 is ByteArray)
  720.                   {
  721.                      _loc8_ = byteArrayCompare(param1 as ByteArray,param2 as ByteArray);
  722.                   }
  723.                   else
  724.                   {
  725.                      if(getQualifiedClassName(param1) != getQualifiedClassName(param2))
  726.                      {
  727.                         return 1;
  728.                      }
  729.                      _loc12_ = getClassInfo(param1).properties;
  730.                      if(getQualifiedClassName(param1) == "Object")
  731.                      {
  732.                         _loc13_ = getClassInfo(param2).properties;
  733.                         _loc8_ = arrayCompare(_loc12_,_loc13_,param3,_loc9_,param5);
  734.                      }
  735.                      if(_loc8_ != 0)
  736.                      {
  737.                         return _loc8_;
  738.                      }
  739.                      _loc17_ = 0;
  740.                      while(_loc17_ < _loc12_.length)
  741.                      {
  742.                         _loc14_ = _loc12_[_loc17_];
  743.                         _loc15_ = param1[_loc14_];
  744.                         _loc16_ = param2[_loc14_];
  745.                         _loc8_ = internalCompare(_loc15_,_loc16_,param3 + 1,_loc9_,param5);
  746.                         if(_loc8_ != 0)
  747.                         {
  748.                            _loc17_ = int(_loc12_.length);
  749.                         }
  750.                         _loc17_++;
  751.                      }
  752.                   }
  753.                   break;
  754.             }
  755.             return _loc8_;
  756.          }
  757.          return stringCompare(_loc6_,_loc7_);
  758.       }
  759.       
  760.       public static function hasMetadata(param1:Object, param2:String, param3:String, param4:Array = null, param5:Object = null) : Boolean
  761.       {
  762.          var _loc6_:Object = getClassInfo(param1,param4,param5);
  763.          var _loc7_:Object = _loc6_["metadata"];
  764.          return internalHasMetadata(_loc7_,param2,param3);
  765.       }
  766.       
  767.       private static function internalHasMetadata(param1:Object, param2:String, param3:String) : Boolean
  768.       {
  769.          var _loc4_:Object = null;
  770.          if(param1 != null)
  771.          {
  772.             _loc4_ = param1[param2];
  773.             if(_loc4_ != null)
  774.             {
  775.                if(_loc4_[param3] != null)
  776.                {
  777.                   return true;
  778.                }
  779.             }
  780.          }
  781.          return false;
  782.       }
  783.       
  784.       public static function toString(param1:Object, param2:Array = null, param3:Array = null) : String
  785.       {
  786.          if(param3 == null)
  787.          {
  788.             param3 = defaultToStringExcludes;
  789.          }
  790.          refCount = 0;
  791.          return internalToString(param1,0,null,param2,param3);
  792.       }
  793.       
  794.       private static function byteArrayCompare(param1:ByteArray, param2:ByteArray) : int
  795.       {
  796.          var _loc4_:int = 0;
  797.          var _loc3_:int = 0;
  798.          if(param1.length != param2.length)
  799.          {
  800.             if(param1.length < param2.length)
  801.             {
  802.                _loc3_ = -1;
  803.             }
  804.             else
  805.             {
  806.                _loc3_ = 1;
  807.             }
  808.          }
  809.          else
  810.          {
  811.             param1.position = 0;
  812.             param2.position = 0;
  813.             _loc4_ = 0;
  814.             while(_loc4_ < param1.length)
  815.             {
  816.                _loc3_ = numericCompare(param1.readByte(),param2.readByte());
  817.                if(_loc3_ != 0)
  818.                {
  819.                   _loc4_ = int(param1.length);
  820.                }
  821.                _loc4_++;
  822.             }
  823.          }
  824.          return _loc3_;
  825.       }
  826.       
  827.       public static function copy(param1:Object) : Object
  828.       {
  829.          var _loc2_:ByteArray = new ByteArray();
  830.          _loc2_.writeObject(param1);
  831.          _loc2_.position = 0;
  832.          return _loc2_.readObject();
  833.       }
  834.       
  835.       private static function getCacheKey(param1:Object, param2:Array = null, param3:Object = null) : String
  836.       {
  837.          var _loc5_:uint = 0;
  838.          var _loc6_:String = null;
  839.          var _loc7_:String = null;
  840.          var _loc8_:String = null;
  841.          var _loc4_:String = getQualifiedClassName(param1);
  842.          if(param2 != null)
  843.          {
  844.             _loc5_ = 0;
  845.             while(_loc5_ < param2.length)
  846.             {
  847.                _loc6_ = param2[_loc5_] as String;
  848.                if(_loc6_ != null)
  849.                {
  850.                   _loc4_ += _loc6_;
  851.                }
  852.                _loc5_++;
  853.             }
  854.          }
  855.          if(param3 != null)
  856.          {
  857.             for(_loc7_ in param3)
  858.             {
  859.                _loc4_ += _loc7_;
  860.                _loc8_ = param3[_loc7_] as String;
  861.                if(_loc8_ != null)
  862.                {
  863.                   _loc4_ += _loc8_;
  864.                }
  865.             }
  866.          }
  867.          return _loc4_;
  868.       }
  869.    }
  870. }
  871.  
  872.